#include <stdio.h>
#include <stdlib.h>
#define N  10
//邻接矩阵数据结构
typedef  struct
{
    int vcount;//顶点数
    int type;//0 无向图，1 有向图
    char  vexs[N];     // 顶点信息
    int  arcs[N][N]; //关系矩阵
} GraphMatrix;

//邻接表数据结构
struct EdgeNode
{ //边表中的结点
    int  endvex;     //相邻顶点在顶点表中下标
    int  weight;  //边的权
    struct EdgeNode* nextedge;   //链字段
};
typedef struct EdgeNode* EdgeList;

typedef struct
{
    char  vertex;  //记录顶点信息
    int degree;//用于记录顶点的入度，在拓扑排序时需使用
    EdgeList  edgelist;  //指向边表的指针
} VexNode;

typedef struct {
    VexNode  vexs[N];  //N个顶点
    int type;//0 无向图，1 有向图
    int vcount;//顶点数
} GraphList;



/*第一关 完成图初始化
*/
void printGraph(GraphMatrix* G)
{//本函数输出图的邻接矩阵
    int i, j;
    for (i = 0; i < G->vcount; i++)
    {
        //  printf("%c ",G->vexs[i]);
        for (j = 0; j < G->vcount; j++)
            printf("%d ", G->arcs[i][j]);
        printf("\n");
    }
}

/*第一关 完成图初始化-邻接矩阵
*/
GraphMatrix* initGraphMatrix()
{
    /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
  输出邻接矩阵，不需要考虑输入的数字非法情况，不输入顶点的信息*/
    GraphMatrix* Ga = (GraphMatrix*)malloc(sizeof(GraphMatrix));
    int sum, x, y;
    scanf("%d%d%d", &Ga->type, &Ga->vcount, &sum);
    for (int i = 0; i < Ga->vcount; i++)
    {
        for (int j = 0; j < Ga->vcount; j++)
        {
            Ga->arcs[i][j] = 0;
        }
    }
    for (int i = 0; i < sum; i++)
    {
        scanf("%d%d", &x, &y);
        Ga->arcs[x][y] = 1;
        if (Ga->type == 0)
        {
            Ga->arcs[y][x] = 1;
        }
    }
    return Ga;
}
/*第二关 完成图初始化-邻接表,并完成输出图的邻接表函数
*/
GraphList* initGraphList()
{
    /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
  输出邻接表。不需考虑输入的数字非法情况，输入顶点的信息*/
    GraphList* Ga = (GraphList*)malloc(sizeof(GraphList));
    int sum, x, y;
    scanf("%d%d%d", &Ga->type, &Ga->vcount, &sum);
    getchar();
    for (int i = 0; i < Ga->vcount; i++)
    {
        Ga->vexs[i].edgelist = NULL;
        scanf("%c", &Ga->vexs[i].vertex);
    }
    for (int i = 0; i < sum; i++)
    {
        scanf("%d%d", &x, &y);
        struct EdgeNode* p;
        p = (EdgeList)malloc(sizeof(struct EdgeNode));
        p->endvex = y;
        p->nextedge = Ga->vexs[x].edgelist;
        Ga->vexs[x].edgelist = p;
        if (Ga->type == 0)
        {
            p = (EdgeList)malloc(sizeof(struct EdgeNode));
            p->endvex = x;
            p->nextedge = Ga->vexs[y].edgelist;
            Ga->vexs[y].edgelist = p;
        }
    }
    return Ga;
}



void printGraphLit(GraphList* G)
{
    /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/
    for (int i = 0; i < G->vcount; i++)
    {
        printf("%c->", G->vexs[i].vertex);
        if (G->vexs[i].edgelist == NULL)
        {
            continue;
        }
        EdgeList p;
        p = G->vexs[i].edgelist;
        while (p)
        {
            if (p->nextedge == NULL)
            {
                printf("%d\n", p->endvex);
            }
            else
            {
                printf("%d->", p->endvex);
            }
            p = p->nextedge;
        }


    }
}


/*第三关 完成图的广度遍历（周游），可根据需要添加自定义函数
*/
void BFS_list(GraphList* G)
{
    int va[N];
    int ve[N];
    for (int i = 0; i < G->vcount; i++)
    {
        va[i] = 0;
    }
    int n = 0, m = 0;
    for (int i = 0; i < G->vcount; i++)
    {
        if (va[i] == 0)
        {
            m = n = 0;
            va[i] = 1;
            printf("%d ", i);
            EdgeList p = G->vexs[i].edgelist;
            while (p)
            {
                if (va[p->endvex] == 0)
                {
                    ve[n] = p->endvex;
                    n++;
                    va[p->endvex] = 1;
                }
                p = p->nextedge;
            }
            while (m < n)
            {
                printf("%d ", ve[m]);
                EdgeList p = G->vexs[ve[m]].edgelist;
                while (p)
                {
                    if (va[p->endvex] == 0)
                    {
                        ve[n] = p->endvex;
                        va[p->endvex] = 1;
                        n++;
                    }
                    p = p->nextedge;
                }
                m++;
            }
        }
    }
}

/*第四关 完成图的深度遍历（周游），可根据需要添加自定义函数
*/

void DFS(GraphList* G, int* va, int i)
{
    EdgeList temp1 = NULL;
    va[i] = 1;
    printf("%d ", i);
    temp1 = G->vexs[i].edgelist;
    while (temp1 != NULL)
    {
        if (!va[temp1->endvex])
        {
            DFS(G, va, temp1->endvex);
        }
        temp1 = temp1->nextedge;
    }
}

void DFS_list(GraphList* G)
{
    int* va = (int*)malloc(sizeof(int) * G->vcount);
    for (int i = 0; i < G->vcount; i++)
    {
        va[i] = 0;
    }
    for (int i = 0; i < G->vcount; i++)
    {
        if (!va[i])
        {
            DFS(G, va, i);
        }
    }
}























#include <stdio.h>
#include <stdlib.h>
#define N  6
//邻接矩阵数据结构
typedef  struct{
    int vcount;//顶点数
    int type ;//0 无向图，1 有向图
    char  vexs[N]  ;     // 顶点信息
    int  arcs[N][N]; //关系矩阵
} GraphMatrix;

//邻接表数据结构
struct EdgeNode { //边表中的结点
    int  endvex;     //相邻顶点在顶点表中下标
    int  weight;  //边的权
    struct EdgeNode  * nextedge;   //链字段
};
typedef struct EdgeNode * EdgeList;

typedef struct
{
    char  vertex;  //记录顶点信息
    int degree;//用于记录顶点的入度，在拓扑排序时需使用
    EdgeList  edgelist;  //指向边表的指针
} VexNode;
typedef struct{
    VexNode  vexs[N];  //N个顶点
    int type ;//0 无向图，1 有向图
    int vcount;//顶点数
} GraphList;



/*第一关 完成图初始化
*/
void printGraph(GraphMatrix *G)
{//本函数输出图的邻接矩阵
    int i,j;
    for(i=0;i<G->vcount;i++)
    {
//  printf("%c ",G->vexs[i]);
        for( j=0;j<G->vcount;j++)
            printf("%d ",G->arcs[i][j]);
        printf("\n");
    }
}

/*第一关 完成图初始化-邻接矩阵
*/
GraphMatrix *initGraphMatrix( )
{
    /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
  输出邻接矩阵，不需要考虑输入的数字非法情况，不输入顶点的信息*/
    GraphMatrix *G=(GraphMatrix*)malloc(sizeof(GraphMatrix));
    int b;
    for(int i=0;i<N;++i)
        for(int j=0;j<N;++j)
            G->arcs[i][j]=0;
    scanf("%d%d%d",&G->type,&G->vcount,&b);
    for(int i=1;i<=b;++i)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        G->arcs[x][y]=1;
        if(G->type==0)G->arcs[y][x]=1;
    }
    return G;
}
/*第二关 完成图初始化-邻接表,并完成输出图的邻接表函数
*/
struct node
{
    int to;int nxt;int val;
}edge[200005];
int cnt2=0,head[200005];
void add(int a,int b,int c)
{
    edge[++cnt2].to=b;
    edge[cnt2].val=c;
    edge[cnt2].nxt=head[a];
    head[a]=cnt2;
}

int type,v,e,xh,a,b,c;
int in[10005];
GraphList *initGraphList( )
{
    /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
  输出邻接表。不需考虑输入的数字非法情况，输入顶点的信息*/
    GraphList *G=(GraphList*)malloc(sizeof(GraphList));
    scanf("%d%d%d",&type,&v,&e);
    //序号处理略
    scanf("%d",&xh);
    for(int i=0;i<e;++i)
    {
        //scanf("%d%d",&a,&b);
        //add(a,b,1);
        //in[b]++;
        //if(type==0)add(b,a,1);
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        if(type==0)add(b,a,c);
    }
    return G;
}



void printGraphLit(GraphList *G)
{
    /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/
    for(int i=0;i<v;++i)
    {
        printf("%d",i);
        for(int j=head[i];j;j=edge[j].nxt)
            printf("->%d",edge[j].to);
        printf("\n");
    }

}

/*第三关 完成图的广度遍历（周游）·，可根据需要添加自定义函数
*/
int que[10005],qf,qr,vis[10005];
void BFS_list(GraphList *G)
{
    que[qr++]=0;
    while(qf!=qr)
    {
        int b=que[qf++];
        if(vis[b]==1)continue;
        printf("%d ",b);
        vis[b]=1;
        for(int i=head[b];i!=0;i=edge[i].nxt)
        {
            if(vis[edge[i].to]==0)que[qr++]=edge[i].to;
        }
    }

}

/*第四关 完成图的深度遍历（周游），可根据需要添加自定义函数
*/
void dfs(int x)
{
    printf("%d ",x);
    vis[x]=1;
    for(int i=head[x];i!=0;i=edge[i].nxt)
    {
        if(vis[edge[i].to]==0)dfs(edge[i].to);
    }
}
void DFS_list(GraphList *G)
{
    dfs(0);
}

/*第五关 生成图的拓扑排序，可根据需要添加自定义函数
*/

void Top_list(GraphList *G)
{
    for(int i=0;i<v;++i)
        if(in[i]==0)que[qr++]=i;
    while(qf!=qr)
    {
        int b=que[qf++];
        printf("%d ",b);
        for(int i=head[b];i!=0;i=edge[i].nxt)
        {
            in[edge[i].to]--;
            if(in[edge[i].to]==0)que[qr++]=edge[i].to;
        }
    }
    //上面代码输出0 1 4 2 3 5也满足拓扑排序，之所以输出不同是因为根据邻接表的储存顺序，先删掉的边是1->4边，4的入度先变为0压入队列。


/*第六关 prim算法生成最小生成树
*/

    int prim[10005],cnt,pa,pb;
    void Prim_list(GraphList *G)//没有堆优化的时间复杂度很差，仅供参考算法思想
    {
        prim[++cnt]=0;//存入当前一共加入了几个点
        vis[0]=1;
        while(cnt<v)
        {
            int maxx=1000000007;
            for(int i=1;i<=cnt;++i)//找到与加入的所有点集相邻最近的点，并使它加入
            {
                for(int j=head[prim[i]];j!=0;j=edge[j].nxt)
                {
                    if(vis[edge[j].to]==0&&edge[j].val<maxx)
                    {
                        maxx=edge[j].val;pa=prim[i];pb=edge[j].to;
                    }
                }
            }
            printf("%d %d\n",pa,pb);
            prim[++cnt]=pb;
            vis[pb]=1;
        }


    }
/*第七关 Kruskal算法生成最小生成树
*/


    void Kruskal_list(GraphList *G)
    {


    }

/*第八关 Dijistra算法求最短路径
*/

    void Dijkstra_list(GraphList *G)
    {


    }
    */
#include <stdio.h>
#include <stdlib.h>
#define N  6
//邻接矩阵数据结构
    typedef  struct{
        int vcount;//顶点数
        int type ;//0 无向图，1 有向图
        char  vexs[N]  ;     // 顶点信息
        int  arcs[N][N]; //关系矩阵
    } GraphMatrix;

//邻接表数据结构
    struct EdgeNode { //边表中的结点
        int  endvex;     //相邻顶点在顶点表中下标
        int  weight;  //边的权
        struct EdgeNode  * nextedge;   //链字段
    };
    typedef struct EdgeNode * EdgeList;

    typedef struct
    {
        char  vertex;  //记录顶点信息
        int degree;//用于记录顶点的入度，在拓扑排序时需使用
        EdgeList  edgelist;  //指向边表的指针
    } VexNode;
    typedef struct{
        VexNode  vexs[N];  //N个顶点
        int type ;//0 无向图，1 有向图
        int vcount;//顶点数
    } GraphList;



/*第一关 完成图初始化
*/
    void printGraph(GraphMatrix *G)
    {//本函数输出图的邻接矩阵
        int i,j;
        for(i=0;i<G->vcount;i++)
        {
//  printf("%c ",G->vexs[i]);
            for( j=0;j<G->vcount;j++)
                printf("%d ",G->arcs[i][j]);
            printf("\n");
        }
    }

/*第一关 完成图初始化-邻接矩阵
*/
    GraphMatrix *initGraphMatrix( )
    {
        /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
      输出邻接矩阵，不需要考虑输入的数字非法情况，不输入顶点的信息*/
        GraphMatrix *G=(GraphMatrix*)malloc(sizeof(GraphMatrix));
        int b;
        for(int i=0;i<N;++i)
            for(int j=0;j<N;++j)
                G->arcs[i][j]=0;
        scanf("%d%d%d",&G->type,&G->vcount,&b);
        for(int i=1;i<=b;++i)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            G->arcs[x][y]=1;
            if(G->type==0)G->arcs[y][x]=1;
        }
        return G;
    }
/*第二关 完成图初始化-邻接表,并完成输出图的邻接表函数
*/
    struct node
    {
        int to;int nxt;int val;
    }edge[200005];
    int cnt2=0,head[200005];
    void add(int a,int b,int c)
    {
        edge[++cnt2].to=b;
        edge[cnt2].val=c;
        edge[cnt2].nxt=head[a];
        head[a]=cnt2;
    }

    int type,v,e,xh,a,b,c;
    int in[10005];
    GraphList *initGraphList( )
    {
        /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
      输出邻接表。不需考虑输入的数字非法情况，输入顶点的信息*/
        GraphList *G=(GraphList*)malloc(sizeof(GraphList));
        scanf("%d%d%d",&type,&v,&e);
        //序号处理略
        scanf("%d",&xh);
        for(int i=0;i<e;++i)
        {
            //scanf("%d%d",&a,&b);
            //add(a,b,1);
            //in[b]++;
            //if(type==0)add(b,a,1);
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
            if(type==0)add(b,a,c);
        }
        return G;
    }



    void printGraphLit(GraphList *G)
    {
        /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/
        for(int i=0;i<v;++i)
        {
            printf("%d",i);
            for(int j=head[i];j;j=edge[j].nxt)
                printf("->%d",edge[j].to);
            printf("\n");
        }

    }

/*第三关 完成图的广度遍历（周游）·，可根据需要添加自定义函数
*/
    int que[10005],qf,qr,vis[10005];
    void BFS_list(GraphList *G)
    {
        que[qr++]=0;
        while(qf!=qr)
        {
            int b=que[qf++];
            if(vis[b]==1)continue;
            printf("%d ",b);
            vis[b]=1;
            for(int i=head[b];i!=0;i=edge[i].nxt)
            {
                if(vis[edge[i].to]==0)que[qr++]=edge[i].to;
            }
        }

    }

/*第四关 完成图的深度遍历（周游），可根据需要添加自定义函数
*/
    void dfs(int x)
    {
        printf("%d ",x);
        vis[x]=1;
        for(int i=head[x];i!=0;i=edge[i].nxt)
        {
            if(vis[edge[i].to]==0)dfs(edge[i].to);
        }
    }
    void DFS_list(GraphList *G)
    {
        dfs(0);
    }

/*第五关 生成图的拓扑排序，可根据需要添加自定义函数
*/

    void Top_list(GraphList *G)
    {
        for(int i=0;i<v;++i)
            if(in[i]==0)que[qr++]=i;
        while(qf!=qr)
        {
            int b=que[qf++];
            printf("%d ",b);
            for(int i=head[b];i!=0;i=edge[i].nxt)
            {
                in[edge[i].to]--;
                if(in[edge[i].to]==0)que[qr++]=edge[i].to;
            }
        }
        //上面代码输出0 1 4 2 3 5也满足拓扑排序，之所以输出不同是因为根据邻接表的储存顺序，先删掉的边是1->4边，4的入度先变为0压入队列。


/*第六关 prim算法生成最小生成树
*/

        int prim[10005],cnt,pa,pb;
        void Prim_list(GraphList *G)//没有堆优化的时间复杂度很差，仅供参考算法思想
        {
            prim[++cnt]=0;//存入当前一共加入了几个点
            vis[0]=1;
            while(cnt<v)
            {
                int maxx=1000000007;
                for(int i=1;i<=cnt;++i)//找到与加入的所有点集相邻最近的点，并使它加入
                {
                    for(int j=head[prim[i]];j!=0;j=edge[j].nxt)
                    {
                        if(vis[edge[j].to]==0&&edge[j].val<maxx)
                        {
                            maxx=edge[j].val;pa=prim[i];pb=edge[j].to;
                        }
                    }
                }
                printf("%d %d\n",pa,pb);
                prim[++cnt]=pb;
                vis[pb]=1;
            }
        }












#include <stdio.h>
#include <stdlib.h>
#define N  6
//邻接矩阵数据结构
        typedef  struct{
            int vcount;//顶点数
            int type ;//0 无向图，1 有向图
            char  vexs[N]  ;     // 顶点信息
            int  arcs[N][N]; //关系矩阵
        } GraphMatrix;

//邻接表数据结构
        struct EdgeNode { //边表中的结点
            int start;
            int fnal;
            int  endvex;     //相邻顶点在顶点表中下标
            int  weight;  //边的权
            struct EdgeNode  * nextedge;   //链字段
        };
        typedef struct EdgeNode * EdgeList;

        typedef struct
        {
            char  vertex;  //记录顶点信息
            int degree;//用于记录顶点的入度，在拓扑排序时需使用
            EdgeList  edgelist;  //指向边表的指针
        } VexNode;
        typedef struct{
            VexNode  vexs[N];  //N个顶点
            int type ;//0 无向图，1 有向图
            int vcount;//顶点数
        } GraphList;



/*第一关 完成图初始化
*/
        void printGraph(GraphMatrix *G)
        {//本函数输出图的邻接矩阵
            int i,j;
            for(i=0;i<G->vcount;i++)
            {
//  printf("%c ",G->vexs[i]);
                for( j=0;j<G->vcount;j++)
                    printf("%d ",G->arcs[i][j]);
                printf("\n");
            }
        }

/*第一关 完成图初始化-邻接矩阵
*/
        GraphMatrix *initGraphMatrix( )
        {
            /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
          输出邻接矩阵，不需要考虑输入的数字非法情况，不输入顶点的信息*/
            GraphMatrix *p=(GraphMatrix *)malloc(sizeof(GraphMatrix ));

            int edgecount;
            scanf("%d %d %d",&p->type,&p->vcount,&edgecount);
            for(int t=0;t<p->vcount;t++){
                for(int k=0;k<p->vcount;k++){
                    p->arcs[t][k]=0;
                }
            }
            for(int t=0;t<edgecount;t++){
                int i,j;
                scanf("%d %d",&i,&j);
                p->arcs[i][j]=1;
                p->arcs[j][i]=1;
            }
            return p;
        }
/*第二关 完成图初始化-邻接表,并完成输出图的邻接表函数
*/
        GraphList *initGraphList( )
        {
            /*第一行输入图的类型、图的顶点数和边数，第二行输入各条边的两顶点的编号，按顶点编号从小到大的顺序输入。
          输出邻接表。不需考虑输入的数字非法情况，输入顶点的信息*/
            GraphList *p=(GraphList *)malloc(sizeof(GraphList ));
            int edgecount;
            scanf("%d %d %d",&p->type,&p->vcount,&edgecount);
            scanf("%s",p->vexs);
            for(int t=0;t<p->vcount;t++){
                p->vexs[t].edgelist=NULL;

            }
            for(int t=0;t<p->vcount;t++){
                p->vexs[t].degree=0;
            }
            for(int t=0;t<edgecount;t++){
                int i,j,w;
                scanf("%d %d",&i,&j);
                scanf("%d",&w);
                if(p->type==1){
                    p->vexs[j].degree++;
                    EdgeList q1=(EdgeList)malloc(sizeof(struct EdgeNode ));
                    q1->nextedge=NULL;
                    q1->endvex=j;
                    q1->nextedge=p->vexs[i].edgelist;
                    p->vexs[i].edgelist=q1;
                }
                else {EdgeList q1=(EdgeList)malloc(sizeof(struct EdgeNode ));
                    EdgeList q2=(EdgeList)malloc(sizeof(struct EdgeNode ));
                    q1->weight=w;
                    q2->weight=w;
                    q1->nextedge=NULL;
                    q2->nextedge=NULL;
                    q1->endvex=j;
                    q2->endvex=i;
                    q1->nextedge=p->vexs[i].edgelist;
                    p->vexs[i].edgelist=q1;
                    q2->nextedge=p->vexs[j].edgelist;
                    p->vexs[j].edgelist=q2;
                }
            }
            return p;
        }



        void printGraphLit( GraphList *G)
        {
            /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/
            for(int i=0;i<G->vcount;i++){
                printf("%d",i);
                EdgeList p=G->vexs[i].edgelist;
                while(p!=NULL){
                    printf("->%d",p->endvex);
                    p=p->nextedge;
                }
                printf("\n");
            }

        }


/*第三关 完成图的广度遍历（周游），可根据需要添加自定义函数
*/
        void BFS_list(GraphList *G)
        {
            int a[100]={0};
            EdgeList p=G->vexs[0].edgelist;
            printf("0 ");
            a[0]=1;
            while(p!=NULL){
                printf("%d ",p->endvex);
                a[p->endvex]=1;
                p=p->nextedge;
            }

            p=G->vexs[0].edgelist;
            while(p!=NULL){
                for(EdgeList q=G->vexs[p->endvex].edgelist;q!=NULL;q=q->nextedge){
                    if(a[q->endvex]!=1){
                        printf("%d ",q->endvex);
                        a[q->endvex]=1;
                    }
                }
                p=p->nextedge;
            }


        }

/*第四关 完成图的深度遍历（周游），可根据需要添加自定义函数
*/
        void dfs(GraphList *G,EdgeList p,int a[]){
            a[p->endvex]=1;
            for(EdgeList q=G->vexs[p->endvex].edgelist;q!=NULL;q=q->nextedge){
                if(a[q->endvex]!=1){printf("%d ",q->endvex);dfs(G,q,a);}
            }
        }
        void DFS_list(GraphList *G)
        {
            int a[100]={0};

            printf("0 ");
            a[0]=1;
            for(EdgeList q=G->vexs[0].edgelist;q!=NULL;q=q->nextedge){
                if(a[q->endvex]!=1){
                    printf("%d ",q->endvex);
                    dfs(G,q,a);
                }
            }

        }

/*第五关 生成图的拓扑排序，可根据需要添加自定义函数
*/
        void top1(GraphList *G,int a[],int i){

            a[i]=1;
            EdgeList p=G->vexs[i].edgelist;
            while(p!=NULL){
                G->vexs[p->endvex].degree--;
                p=p->nextedge;
            }
            for(int j=0;i<G->vcount;i++){
                if(G->vexs[j].degree==0&&a[j]==0){
                    printf("%d ",j);
                    top1(G,a,j);

                }
            }
        }

        void Top_list(GraphList *G)
        {   int a[100]={0};
            int i;
            for(i=0;i<G->vcount;i++){
                if(G->vexs[i].degree==0&&a[i]==0){
                    printf("%d ",i);
                    top1(G,a,i);

                }
            }

        }

/*第六关 prim算法生成最小生成树
*/

        void Prim_list(GraphList *G)
        {
            struct EdgeNode a[G->vcount-1];
            for(int i=0;i<G->vcount-1;i++)
                a[i].weight=10000;
            for(int i=0;i<G->vcount;i++){
                EdgeList p=G->vexs[i].edgelist;
                while(p!=NULL){
                    int t=p->endvex-1;
                    if(p->endvex>i){
                        if(p->weight<a[t].weight){
                            a[t].weight=p->weight;
                            a[t].start=i;
                            a[t].fnal=p->endvex;
                        }
                    }
                    p=p->nextedge;
                }

            }
            if(a[G->vcount-2].weight<a[G->vcount-3].weight)
            {
                struct EdgeNode min;
                min.weight=a[G->vcount-2].weight;
                min.start=a[G->vcount-2].start;
                min.fnal=a[G->vcount-2].fnal;
                a[G->vcount-2].weight=a[G->vcount-3].weight;
                a[G->vcount-2].start=a[G->vcount-3].start;
                a[G->vcount-2].fnal=a[G->vcount-3].fnal;
                a[G->vcount-3].weight=min.weight;
                a[G->vcount-3].start=min.start;
                a[G->vcount-3].fnal=min.fnal;
            }
            for(int i=0;i<G->vcount-1;i++)
                printf("%d %d\n",a[i].start,a[i].fnal);
        }


